package com.zyp.jobseeker.controller;

import com.github.pagehelper.PageInfo;
import com.zyp.jobseeker.entity.Student;
import com.zyp.jobseeker.enums.UserRole;
import com.zyp.jobseeker.service.StudentService;
import com.zyp.jobseeker.utils.JwtUtil;
import com.zyp.jobseeker.utils.ResultUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import java.util.Map;
import java.util.Optional;

/**
 * 学生Controller
 * 处理学生信息管理相关请求
 */
@RestController
@RequestMapping("/api/student")
public class StudentController {
    private static final Logger logger = LoggerFactory.getLogger(StudentController.class);  // 新增日
    @Autowired
    private StudentService studentService;
    @Autowired
    private JwtUtil jwtUtil;


    /**
     * 更新学生信息
     */
    @PutMapping("/update")
    @PreAuthorize("hasRole('STUDENT')")
    public ResultUtil<?> updateStudentInfo(@RequestBody Student student) {
        if (student.getId() == null) {
            return ResultUtil.fail(400, "学生ID不能为空");
        }
        
        if (!studentService.updateStudentInfo(student)) {
            return ResultUtil.fail(500, "学生信息更新失败");
        }
        return ResultUtil.success("学生信息更新成功");
    }


    /**
     * 生成学生简历（Markdown格式）
     */
    @GetMapping("/resume/generate")
    @PreAuthorize("hasAuthority('STUDENT')")  // 学生角色专属
    public ResultUtil<String> generateStudentResume(
            @RequestHeader("Authorization") String token) {  // 从token获取信息
        try {

            // 从请求头中获取token
            if (token == null || !token.startsWith("Bearer ")) {
                return ResultUtil.fail(401, "未提供有效的认证信息");
            }
            token = token.substring(7);
            // 验证token是否过期
            if (jwtUtil.isTokenExpired(token)) {
                return ResultUtil.fail(401, "认证信息已过期，请重新登录");
            }
            logger.info("[学生简历] 收到简历生成请求，token: {}", token);  // 新增日志
            Long studentId = jwtUtil.getUserIdFromToken(token);  // 获取学生ID
            logger.debug("[学生简历] 解析学生ID: {}", studentId);  // 新增日志

            String resumeContent = studentService.generateStudentResume(studentId);

            logger.info("[学生简历] 简历生成成功，内容长度: {}", resumeContent.length());  // 新增日志
            return ResultUtil.success(resumeContent);

        } catch (Exception e) {
            logger.error("[学生简历] 简历生成失败", e);  // 新增日志
            return ResultUtil.fail(500, "简历生成失败: " + e.getMessage());
        }
    }

    /**
     * 管理员/企业搜索学生
     */
    @GetMapping("/search")
    @PreAuthorize("hasAuthority('ADMIN') or hasAuthority('ENTERPRISE')")  // 管理员/企业权限
    public ResultUtil<PageInfo<Map<String, Object>>> searchStudents(
            @RequestHeader("Authorization") String token,  // 获取用户角色
            @RequestParam(required = false) String degree,
            @RequestParam(required = false) String major,
            @RequestParam(required = false) String keyword,
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(defaultValue = "10") int size) {
        try {
            // 从请求头中获取token
            if (token == null || !token.startsWith("Bearer ")) {
                return ResultUtil.fail(401, "未提供有效的认证信息");
            }
            token = token.substring(7);
            // 验证token是否过期
            if (jwtUtil.isTokenExpired(token)) {
                return ResultUtil.fail(401, "认证信息已过期，请重新登录");
            }
            String userRole = UserRole.getByCode(jwtUtil.getRoleFromToken(token)).getDesc();  // 获取用户角色
            logger.info("[学生搜索] 收到搜索请求，参数：degree={}, major={}, keyword={}, page={}, size={}, userRole={}",
                    degree, major, keyword, page, size, userRole);  // 新增日志

            PageInfo<Map<String, Object>> result = studentService.searchStudents(
                    degree, major, keyword, page, size, userRole);

            logger.info("[学生搜索] 查询完成，返回结果数: {}", result.getTotal());  // 新增日志
            return ResultUtil.success(result);

        } catch (Exception e) {
            logger.error("[学生搜索] 查询失败", e);  // 新增日志
            return ResultUtil.fail(500, "学生搜索失败: " + e.getMessage());
        }
    }
    /**
     * 管理员/企业根据学生id获取学生信息
     */
    @GetMapping("/info/{id}")
    @PreAuthorize("hasAuthority('ADMIN') or hasAuthority('ENTERPRISE')")  // 管理员/企业权限
    public ResultUtil<?> getStudentInfo(@PathVariable("id") Long studentId) {
        Optional<Student> student = studentService.findById(studentId);
        return student.map(value -> ResultUtil.success("获取学生信息成功", value))
                .orElseGet(() -> ResultUtil.fail(404, "学生信息不存在"));
    }
    /**
     * 管理员/企业根据学生ID获取简历（Markdown格式）
     */
    @GetMapping("/resume/{id}")
    @PreAuthorize("hasAuthority('ADMIN') or hasAuthority('ENTERPRISE')")  // 管理员/企业权限
    public ResultUtil<String> getStudentResumeById(
            @RequestHeader("Authorization") String token,  // 获取用户角色
            @PathVariable("id") Long studentId) {  // 学生ID路径参数
        try {
            // 验证token
            if (token == null || !token.startsWith("Bearer ")) {
                return ResultUtil.fail(401, "未提供有效的认证信息");
            }
            token = token.substring(7);
            if (jwtUtil.isTokenExpired(token)) {
                return ResultUtil.fail(401, "认证信息已过期，请重新登录");
            }
            String resumeContent = studentService.generateStudentResume(studentId);

            logger.info("[学生简历] 根据ID获取简历成功，内容长度: {}", resumeContent.length());
            return ResultUtil.success(resumeContent);

        } catch (IllegalArgumentException e) {
            logger.warn("[学生简历] 学生信息不存在，studentId={}", studentId, e);
            return ResultUtil.fail(404, "学生信息不存在");
        } catch (Exception e) {
            logger.error("[学生简历] 获取简历失败，studentId={}", studentId, e);
            return ResultUtil.fail(500, "获取学生简历失败: " + e.getMessage());
        }
    }
}


